package com.dragon.modules.yuegou.query.order;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.order.OrderEntity;
import com.dragon.modules.yuegou.enums.order.OrderBuyerType;
import com.dragon.modules.yuegou.enums.order.OrderPayType;
import com.dragon.modules.yuegou.enums.order.OrderPickupType;
import com.dragon.modules.yuegou.enums.order.OrderRefundStatus;
import com.dragon.modules.yuegou.enums.order.OrderSellerType;
import com.dragon.modules.yuegou.enums.order.OrderStatus;
import com.dragon.modules.yuegou.enums.order.OrderType;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 订单 动态查询条件
 * 
 * @author pbuilder generated
 * @date 2020-08-31 14:56:06
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class OrderQuery extends OrderEntity implements Query<OrderEntity> {

    /** 订单号（其它表引用订单号使用order_no）查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

    /** 订单金额（订单物品金额之和)查询条件 */
	@JsonUnwrapped(prefix = "amount")
	private Condition<BigDecimal> amountCondition;

    /** 订单积分查询条件 */
	@JsonUnwrapped(prefix = "points")
	private Condition<Integer> pointsCondition;

    /** 优惠金额（优惠金额之和）查询条件 */
	@JsonUnwrapped(prefix = "couponAmount")
	private Condition<BigDecimal> couponAmountCondition;

    /** 折扣金额（ = SUM((订单物品价格 - 订单物品折扣价) * 数量)）查询条件 */
	@JsonUnwrapped(prefix = "discountAmount")
	private Condition<BigDecimal> discountAmountCondition;

    /** 应付金额 包含运费，运费存在ord_order_shipping查询条件 */
	@JsonUnwrapped(prefix = "payableAmount")
	private Condition<BigDecimal> payableAmountCondition;

    /** 实付金额查询条件 */
	@JsonUnwrapped(prefix = "payAmount")
	private Condition<BigDecimal> payAmountCondition;

    /** 积分支付额度查询条件 */
	@JsonUnwrapped(prefix = "payPoints")
	private Condition<Integer> payPointsCondition;

    /** [枚举]支付类型：0-其他-OTHER、1-悦卡-YUE_CARD、2-悦币-YUE_COIN、3-支付宝-ALIPAY、4-微信-WECHAT、5-积分-POINT查询条件 */
	@JsonUnwrapped(prefix = "payType")
	private Condition<OrderPayType> payTypeCondition;

    /** [枚举]订单状态：0-未付款-NOTPAY、1-已付款/待接单-PAID、2-已完成-SUCCEED、3-已关闭-CLOSED、4-已发货/配送中-SHIPPING、5-已过期-EXPIRED、6-待配送-WAITPOST查询条件 */
	@JsonUnwrapped(prefix = "status")
	private Condition<OrderStatus> statusCondition;

    /** 退款金额查询条件 */
	@JsonUnwrapped(prefix = "refundAmount")
	private Condition<BigDecimal> refundAmountCondition;

    /** [枚举]退款状态：0-未退款-NO_REFUND、1-部分退款-PART_REFUND、2-完全退款-ALL_REFUND查询条件 */
	@JsonUnwrapped(prefix = "refundStatus")
	private Condition<OrderRefundStatus> refundStatusCondition;

    /** 退款备注查询条件 */
	@JsonUnwrapped(prefix = "refundRemarks")
	private Condition<String> refundRemarksCondition;

    /** 下单时间查询条件 */
	@JsonUnwrapped(prefix = "orderTime")
	private Condition<LocalDateTime> orderTimeCondition;

    /** 取消时间查询条件 */
	@JsonUnwrapped(prefix = "cancelTime")
	private Condition<LocalDateTime> cancelTimeCondition;

    /** 交易关闭时间查询条件 */
	@JsonUnwrapped(prefix = "closeTime")
	private Condition<LocalDateTime> closeTimeCondition;

    /** 支付时间查询条件 */
	@JsonUnwrapped(prefix = "payTime")
	private Condition<LocalDateTime> payTimeCondition;

    /** 支付超时时间查询条件 */
	@JsonUnwrapped(prefix = "payExpireTime")
	private Condition<LocalDateTime> payExpireTimeCondition;

    /** 提货超时时间查询条件 */
	@JsonUnwrapped(prefix = "pickupExpireTime")
	private Condition<LocalDateTime> pickupExpireTimeCondition;

    /** 发货时间查询条件 */
	@JsonUnwrapped(prefix = "shippingTime")
	private Condition<LocalDateTime> shippingTimeCondition;

    /** 交易完成时间查询条件 */
	@JsonUnwrapped(prefix = "endTime")
	private Condition<LocalDateTime> endTimeCondition;

    /** [枚举]买家类型：0-会员-MEMBER、2-商户用户-MERCHANT_USER查询条件 */
	@JsonUnwrapped(prefix = "buyerType")
	private Condition<OrderBuyerType> buyerTypeCondition;

    /** 买家ID查询条件 */
	@JsonUnwrapped(prefix = "buyerId")
	private Condition<String> buyerIdCondition;

    /** 卖家昵称查询条件 */
	@JsonUnwrapped(prefix = "buyerNick")
	private Condition<String> buyerNickCondition;

    /** 卖家留言查询条件 */
	@JsonUnwrapped(prefix = "buyerMessage")
	private Condition<String> buyerMessageCondition;

    /** [枚举]卖家类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSD、3-商户-MERCHANT查询条件 */
	@JsonUnwrapped(prefix = "sellerType")
	private Condition<OrderSellerType> sellerTypeCondition;

    /** 集团ID查询条件 */
	@JsonUnwrapped(prefix = "groupId")
	private Condition<String> groupIdCondition;

    /** 商圈ID查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

    /** 商户ID查询条件 */
	@JsonUnwrapped(prefix = "merchantId")
	private Condition<String> merchantIdCondition;

    /** 停车场ID（停车支付订单专用）查询条件 */
	@JsonUnwrapped(prefix = "parkId")
	private Condition<String> parkIdCondition;

    /** 是否虚拟订单（1：虚拟订单，0：非虚拟订单，虚拟订单指所有商品都是虚拟商品的订单）查询条件 */
	@JsonUnwrapped(prefix = "isVirtual")
	private Condition<Boolean> isVirtualCondition;

    /** [枚举]提货类型：0-上门提货-SELF、1-线上授予-ONLINE、2-商户送货-MERCHANT、3-快递-POST查询条件 */
	@JsonUnwrapped(prefix = "pickupType")
	private Condition<OrderPickupType> pickupTypeCondition;

    /** 是否需要上门自提（1：需要，会员自己上门自提，0：不需要）查询条件 */
	@JsonUnwrapped(prefix = "pickup")
	private Condition<Boolean> pickupCondition;

    /** 剩余可提货数量查询条件 */
	@JsonUnwrapped(prefix = "pickupRemain")
	private Condition<Integer> pickupRemainCondition;

    /** 订单层级（0：父订单，1：子订单，仅支持两级结构，子订单精确到卖家，一个订单可以包含多个卖家的商品，子订单中只会有一个卖家的商品）查询条件 */
	@JsonUnwrapped(prefix = "level")
	private Condition<Integer> levelCondition;

    /** 父订单ID查询条件 */
	@JsonUnwrapped(prefix = "parentId")
	private Condition<String> parentIdCondition;

    /** [枚举]类型：0-购物订单-BUY、1-扫码支付-SCAN_PAY、2-停车支付-PARK、3-商户停车券-MERCHANT_COUPON_BUY、4-购买悦卡-CARD_BUY、5-充值悦币-RECHARGE_COIN、6-仪表充值-DOORNO_RECHARGE、7-商户仪表充值-MERCHANT_DOORNO_RECHARGE、8-商户会员等级充值-MERCHANT_LEVEL_BUY、9-疯狂砍价-BARGAIN、10-秒杀-SECKILL、11-限时折扣-LIMIT_SALES、12-积分兑换-POINTS、13-购买套餐-MEAL、14-全民拼团-GROUPON、15-抽奖-LOTTERY、16-物业缴费-PROPERTY_PAY_COST、17-商户物业缴费-MERCHANT_PROPERTY_PAY_COST、18-配送到家-DELIVERY_TO_HOME、19-发放礼包(不能被查询到)-GIVING_GIFT_BAG、20-实体卡支付-ENTITY_CARD_PAY、21-商品券领取-COUPON、22-京东商城订单-JD、23-免费领取-FREE、24-活动订单-ACTIVITY查询条件 */
	@JsonUnwrapped(prefix = "type")
	private Condition<OrderType> typeCondition;

    /** 是否是叶子订单（统计订单金额时，使用叶子订单来统计）查询条件 */
	@JsonUnwrapped(prefix = "leaf")
	private Condition<Boolean> leafCondition;

    /** 旧订单号查询条件 */
	@JsonUnwrapped(prefix = "oldOrderNo")
	private Condition<String> oldOrderNoCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public OrderQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 * 
	 * @param entity 实体对象
	 */
	public OrderQuery(OrderEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 * 
	 * @param other 查询条件对象
	 */
	public OrderQuery(OrderQuery other) {
		super(other);
		if (other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if (other.amountCondition != null) {
			this.amountCondition = other.amountCondition.copy();
		}
		if (other.pointsCondition != null) {
			this.pointsCondition = other.pointsCondition.copy();
		}
		if (other.couponAmountCondition != null) {
			this.couponAmountCondition = other.couponAmountCondition.copy();
		}
		if (other.discountAmountCondition != null) {
			this.discountAmountCondition = other.discountAmountCondition.copy();
		}
		if (other.payableAmountCondition != null) {
			this.payableAmountCondition = other.payableAmountCondition.copy();
		}
		if (other.payAmountCondition != null) {
			this.payAmountCondition = other.payAmountCondition.copy();
		}
		if (other.payPointsCondition != null) {
			this.payPointsCondition = other.payPointsCondition.copy();
		}
		if (other.payTypeCondition != null) {
			this.payTypeCondition = other.payTypeCondition.copy();
		}
		if (other.statusCondition != null) {
			this.statusCondition = other.statusCondition.copy();
		}
		if (other.refundAmountCondition != null) {
			this.refundAmountCondition = other.refundAmountCondition.copy();
		}
		if (other.refundStatusCondition != null) {
			this.refundStatusCondition = other.refundStatusCondition.copy();
		}
		if (other.refundRemarksCondition != null) {
			this.refundRemarksCondition = other.refundRemarksCondition.copy();
		}
		if (other.orderTimeCondition != null) {
			this.orderTimeCondition = other.orderTimeCondition.copy();
		}
		this.setOther(other);
	}
	private void setOther(OrderQuery other) {
		if (other.cancelTimeCondition != null) {
			this.cancelTimeCondition = other.cancelTimeCondition.copy();
		}
		if (other.closeTimeCondition != null) {
			this.closeTimeCondition = other.closeTimeCondition.copy();
		}
		if (other.payTimeCondition != null) {
			this.payTimeCondition = other.payTimeCondition.copy();
		}
		if (other.payExpireTimeCondition != null) {
			this.payExpireTimeCondition = other.payExpireTimeCondition.copy();
		}
		if (other.pickupExpireTimeCondition != null) {
			this.pickupExpireTimeCondition = other.pickupExpireTimeCondition.copy();
		}
		if (other.shippingTimeCondition != null) {
			this.shippingTimeCondition = other.shippingTimeCondition.copy();
		}
		if (other.endTimeCondition != null) {
			this.endTimeCondition = other.endTimeCondition.copy();
		}
		if (other.buyerTypeCondition != null) {
			this.buyerTypeCondition = other.buyerTypeCondition.copy();
		}
		if (other.buyerIdCondition != null) {
			this.buyerIdCondition = other.buyerIdCondition.copy();
		}
		if (other.buyerNickCondition != null) {
			this.buyerNickCondition = other.buyerNickCondition.copy();
		}
		if (other.buyerMessageCondition != null) {
			this.buyerMessageCondition = other.buyerMessageCondition.copy();
		}
		if (other.sellerTypeCondition != null) {
			this.sellerTypeCondition = other.sellerTypeCondition.copy();
		}
		if (other.groupIdCondition != null) {
			this.groupIdCondition = other.groupIdCondition.copy();
		}
		if (other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		this.setOther2(other);
	}
	private void setOther2(OrderQuery other){
		if(other.merchantIdCondition != null) {
			this.merchantIdCondition = other.merchantIdCondition.copy();
		}
		if(other.parkIdCondition != null) {
			this.parkIdCondition = other.parkIdCondition.copy();
		}
		if(other.isVirtualCondition != null) {
			this.isVirtualCondition = other.isVirtualCondition.copy();
		}
		if(other.pickupTypeCondition != null) {
			this.pickupTypeCondition = other.pickupTypeCondition.copy();
		}
		if(other.pickupCondition != null) {
			this.pickupCondition = other.pickupCondition.copy();
		}
		if(other.pickupRemainCondition != null) {
			this.pickupRemainCondition = other.pickupRemainCondition.copy();
		}
		if(other.levelCondition != null) {
			this.levelCondition = other.levelCondition.copy();
		}
		if(other.parentIdCondition != null) {
			this.parentIdCondition = other.parentIdCondition.copy();
		}
		if(other.typeCondition != null) {
			this.typeCondition = other.typeCondition.copy();
		}
		if(other.leafCondition != null) {
			this.leafCondition = other.leafCondition.copy();
		}
		if(other.oldOrderNoCondition != null) {
			this.oldOrderNoCondition = other.oldOrderNoCondition.copy();
		}
	}

	@Override
	public QueryWrapper<OrderEntity> toQueryWrapper() {
		QueryWrapper<OrderEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (amountCondition != null) {
			amountCondition.toWrapper(wrapper, COL_AMOUNT);
		}
		if (pointsCondition != null) {
			pointsCondition.toWrapper(wrapper, COL_POINTS);
		}
		if (couponAmountCondition != null) {
			couponAmountCondition.toWrapper(wrapper, COL_COUPON_AMOUNT);
		}
		if (discountAmountCondition != null) {
			discountAmountCondition.toWrapper(wrapper, COL_DISCOUNT_AMOUNT);
		}
		if (payableAmountCondition != null) {
			payableAmountCondition.toWrapper(wrapper, COL_PAYABLE_AMOUNT);
		}
		if (payAmountCondition != null) {
			payAmountCondition.toWrapper(wrapper, COL_PAY_AMOUNT);
		}
		if (payPointsCondition != null) {
			payPointsCondition.toWrapper(wrapper, COL_PAY_POINTS);
		}
		if (payTypeCondition != null) {
			payTypeCondition.toWrapper(wrapper, COL_PAY_TYPE);
		}
		if (statusCondition != null) {
			statusCondition.toWrapper(wrapper, COL_STATUS);
		}
		if (refundAmountCondition != null) {
			refundAmountCondition.toWrapper(wrapper, COL_REFUND_AMOUNT);
		}
		if (refundStatusCondition != null) {
			refundStatusCondition.toWrapper(wrapper, COL_REFUND_STATUS);
		}
		if (refundRemarksCondition != null) {
			refundRemarksCondition.toWrapper(wrapper, COL_REFUND_REMARKS);
		}
		if (orderTimeCondition != null) {
			orderTimeCondition.toWrapper(wrapper, COL_ORDER_TIME);
		}
		return getQueryWrapper(wrapper);
	}
	private QueryWrapper<OrderEntity> getQueryWrapper(QueryWrapper<OrderEntity> wrapper){
		if (cancelTimeCondition != null) {
			cancelTimeCondition.toWrapper(wrapper, COL_CANCEL_TIME);
		}
		if (closeTimeCondition != null) {
			closeTimeCondition.toWrapper(wrapper, COL_CLOSE_TIME);
		}
		if (payTimeCondition != null) {
			payTimeCondition.toWrapper(wrapper, COL_PAY_TIME);
		}
		if (payExpireTimeCondition != null) {
			payExpireTimeCondition.toWrapper(wrapper, COL_PAY_EXPIRE_TIME);
		}
		if (pickupExpireTimeCondition != null) {
			pickupExpireTimeCondition.toWrapper(wrapper, COL_PICKUP_EXPIRE_TIME);
		}
		if (shippingTimeCondition != null) {
			shippingTimeCondition.toWrapper(wrapper, COL_SHIPPING_TIME);
		}
		if (endTimeCondition != null) {
			endTimeCondition.toWrapper(wrapper, COL_END_TIME);
		}
		if (buyerTypeCondition != null) {
			buyerTypeCondition.toWrapper(wrapper, COL_BUYER_TYPE);
		}
		if (buyerIdCondition != null) {
			buyerIdCondition.toWrapper(wrapper, COL_BUYER_ID);
		}
		if (buyerNickCondition != null) {
			buyerNickCondition.toWrapper(wrapper, COL_BUYER_NICK);
		}
		if (buyerMessageCondition != null) {
			buyerMessageCondition.toWrapper(wrapper, COL_BUYER_MESSAGE);
		}
		if (sellerTypeCondition != null) {
			sellerTypeCondition.toWrapper(wrapper, COL_SELLER_TYPE);
		}
		if (groupIdCondition != null) {
			groupIdCondition.toWrapper(wrapper, COL_GROUP_ID);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		return getQueryWrapper2(wrapper);
	}

	private QueryWrapper<OrderEntity> getQueryWrapper2(QueryWrapper<OrderEntity> wrapper){
		if (merchantIdCondition != null) {
			merchantIdCondition.toWrapper(wrapper, COL_MERCHANT_ID);
		}
		if (parkIdCondition != null) {
			parkIdCondition.toWrapper(wrapper, COL_PARK_ID);
		}
		if (isVirtualCondition != null) {
			isVirtualCondition.toWrapper(wrapper, COL_IS_VIRTUAL);
		}
		if (pickupTypeCondition != null) {
			pickupTypeCondition.toWrapper(wrapper, COL_PICKUP_TYPE);
		}
		if (pickupCondition != null) {
			pickupCondition.toWrapper(wrapper, COL_PICKUP);
		}
		if (pickupRemainCondition != null) {
			pickupRemainCondition.toWrapper(wrapper, COL_PICKUP_REMAIN);
		}
		if (levelCondition != null) {
			levelCondition.toWrapper(wrapper, COL_LEVEL);
		}
		if (parentIdCondition != null) {
			parentIdCondition.toWrapper(wrapper, COL_PARENT_ID);
		}
		if (typeCondition != null) {
			typeCondition.toWrapper(wrapper, COL_TYPE);
		}
		if (leafCondition != null) {
			leafCondition.toWrapper(wrapper, COL_LEAF);
		}
		if (oldOrderNoCondition != null) {
			oldOrderNoCondition.toWrapper(wrapper, COL_OLD_ORDER_NO);
		}
		return wrapper;
	}

	/**
	 * 构造并返回订单号（其它表引用订单号使用order_no）查询条件
	 * 
	 * @return idCondition 订单号（其它表引用订单号使用order_no）查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}
	
	/**
	 * 获取订单号（其它表引用订单号使用order_no）查询条件
	 * 
	 * @return idCondition 订单号（其它表引用订单号使用order_no）查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置订单号（其它表引用订单号使用order_no）查询条件
	 * 
	 * @param idCondition 订单号（其它表引用订单号使用order_no）查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回订单金额（订单物品金额之和)查询条件
	 * 
	 * @return amountCondition 订单金额（订单物品金额之和)查询条件
	 */
	public Condition<BigDecimal> amount() {
		this.amountCondition = new Condition<>();
		return this.amountCondition;
	}
	
	/**
	 * 获取订单金额（订单物品金额之和)查询条件
	 * 
	 * @return amountCondition 订单金额（订单物品金额之和)查询条件
	 */
	public Condition<BigDecimal> getAmountCondition() {
		return amountCondition;
	}

	/**
	 * 设置订单金额（订单物品金额之和)查询条件
	 * 
	 * @param amountCondition 订单金额（订单物品金额之和)查询条件
	 */
	public void setAmountCondition(Condition<BigDecimal> amountCondition) {
		this.amountCondition = amountCondition;
	}

	/**
	 * 构造并返回订单积分查询条件
	 * 
	 * @return pointsCondition 订单积分查询条件
	 */
	public Condition<Integer> points() {
		this.pointsCondition = new Condition<>();
		return this.pointsCondition;
	}
	
	/**
	 * 获取订单积分查询条件
	 * 
	 * @return pointsCondition 订单积分查询条件
	 */
	public Condition<Integer> getPointsCondition() {
		return pointsCondition;
	}

	/**
	 * 设置订单积分查询条件
	 * 
	 * @param pointsCondition 订单积分查询条件
	 */
	public void setPointsCondition(Condition<Integer> pointsCondition) {
		this.pointsCondition = pointsCondition;
	}

	/**
	 * 构造并返回优惠金额（优惠金额之和）查询条件
	 * 
	 * @return couponAmountCondition 优惠金额（优惠金额之和）查询条件
	 */
	public Condition<BigDecimal> couponAmount() {
		this.couponAmountCondition = new Condition<>();
		return this.couponAmountCondition;
	}
	
	/**
	 * 获取优惠金额（优惠金额之和）查询条件
	 * 
	 * @return couponAmountCondition 优惠金额（优惠金额之和）查询条件
	 */
	public Condition<BigDecimal> getCouponAmountCondition() {
		return couponAmountCondition;
	}

	/**
	 * 设置优惠金额（优惠金额之和）查询条件
	 * 
	 * @param couponAmountCondition 优惠金额（优惠金额之和）查询条件
	 */
	public void setCouponAmountCondition(Condition<BigDecimal> couponAmountCondition) {
		this.couponAmountCondition = couponAmountCondition;
	}

	/**
	 * 构造并返回折扣金额（ = SUM((订单物品价格 - 订单物品折扣价) * 数量)）查询条件
	 * 
	 * @return discountAmountCondition 折扣金额（ = SUM((订单物品价格 - 订单物品折扣价) * 数量)）查询条件
	 */
	public Condition<BigDecimal> discountAmount() {
		this.discountAmountCondition = new Condition<>();
		return this.discountAmountCondition;
	}
	
	/**
	 * 获取折扣金额（ = SUM((订单物品价格 - 订单物品折扣价) * 数量)）查询条件
	 * 
	 * @return discountAmountCondition 折扣金额（ = SUM((订单物品价格 - 订单物品折扣价) * 数量)）查询条件
	 */
	public Condition<BigDecimal> getDiscountAmountCondition() {
		return discountAmountCondition;
	}

	/**
	 * 设置折扣金额（ = SUM((订单物品价格 - 订单物品折扣价) * 数量)）查询条件
	 * 
	 * @param discountAmountCondition 折扣金额（ = SUM((订单物品价格 - 订单物品折扣价) * 数量)）查询条件
	 */
	public void setDiscountAmountCondition(Condition<BigDecimal> discountAmountCondition) {
		this.discountAmountCondition = discountAmountCondition;
	}

	/**
	 * 构造并返回应付金额 包含运费，运费存在ord_order_shipping查询条件
	 * 
	 * @return payableAmountCondition 应付金额 包含运费，运费存在ord_order_shipping查询条件
	 */
	public Condition<BigDecimal> payableAmount() {
		this.payableAmountCondition = new Condition<>();
		return this.payableAmountCondition;
	}
	
	/**
	 * 获取应付金额 包含运费，运费存在ord_order_shipping查询条件
	 * 
	 * @return payableAmountCondition 应付金额 包含运费，运费存在ord_order_shipping查询条件
	 */
	public Condition<BigDecimal> getPayableAmountCondition() {
		return payableAmountCondition;
	}

	/**
	 * 设置应付金额 包含运费，运费存在ord_order_shipping查询条件
	 * 
	 * @param payableAmountCondition 应付金额 包含运费，运费存在ord_order_shipping查询条件
	 */
	public void setPayableAmountCondition(Condition<BigDecimal> payableAmountCondition) {
		this.payableAmountCondition = payableAmountCondition;
	}

	/**
	 * 构造并返回实付金额查询条件
	 * 
	 * @return payAmountCondition 实付金额查询条件
	 */
	public Condition<BigDecimal> payAmount() {
		this.payAmountCondition = new Condition<>();
		return this.payAmountCondition;
	}
	
	/**
	 * 获取实付金额查询条件
	 * 
	 * @return payAmountCondition 实付金额查询条件
	 */
	public Condition<BigDecimal> getPayAmountCondition() {
		return payAmountCondition;
	}

	/**
	 * 设置实付金额查询条件
	 * 
	 * @param payAmountCondition 实付金额查询条件
	 */
	public void setPayAmountCondition(Condition<BigDecimal> payAmountCondition) {
		this.payAmountCondition = payAmountCondition;
	}

	/**
	 * 构造并返回积分支付额度查询条件
	 * 
	 * @return payPointsCondition 积分支付额度查询条件
	 */
	public Condition<Integer> payPoints() {
		this.payPointsCondition = new Condition<>();
		return this.payPointsCondition;
	}
	
	/**
	 * 获取积分支付额度查询条件
	 * 
	 * @return payPointsCondition 积分支付额度查询条件
	 */
	public Condition<Integer> getPayPointsCondition() {
		return payPointsCondition;
	}

	/**
	 * 设置积分支付额度查询条件
	 * 
	 * @param payPointsCondition 积分支付额度查询条件
	 */
	public void setPayPointsCondition(Condition<Integer> payPointsCondition) {
		this.payPointsCondition = payPointsCondition;
	}

	/**
	 * 构造并返回[枚举]支付类型：0-其他-OTHER、1-悦卡-YUE_CARD、2-悦币-YUE_COIN、3-支付宝-ALIPAY、4-微信-WECHAT、5-积分-POINT查询条件
	 * 
	 * @return payTypeCondition [枚举]支付类型：0-其他-OTHER、1-悦卡-YUE_CARD、2-悦币-YUE_COIN、3-支付宝-ALIPAY、4-微信-WECHAT、5-积分-POINT查询条件
	 */
	public Condition<OrderPayType> payType() {
		this.payTypeCondition = new Condition<>();
		return this.payTypeCondition;
	}
	
	/**
	 * 获取[枚举]支付类型：0-其他-OTHER、1-悦卡-YUE_CARD、2-悦币-YUE_COIN、3-支付宝-ALIPAY、4-微信-WECHAT、5-积分-POINT查询条件
	 * 
	 * @return payTypeCondition [枚举]支付类型：0-其他-OTHER、1-悦卡-YUE_CARD、2-悦币-YUE_COIN、3-支付宝-ALIPAY、4-微信-WECHAT、5-积分-POINT查询条件
	 */
	public Condition<OrderPayType> getPayTypeCondition() {
		return payTypeCondition;
	}

	/**
	 * 设置[枚举]支付类型：0-其他-OTHER、1-悦卡-YUE_CARD、2-悦币-YUE_COIN、3-支付宝-ALIPAY、4-微信-WECHAT、5-积分-POINT查询条件
	 * 
	 * @param payTypeCondition [枚举]支付类型：0-其他-OTHER、1-悦卡-YUE_CARD、2-悦币-YUE_COIN、3-支付宝-ALIPAY、4-微信-WECHAT、5-积分-POINT查询条件
	 */
	public void setPayTypeCondition(Condition<OrderPayType> payTypeCondition) {
		this.payTypeCondition = payTypeCondition;
	}

	/**
	 * 构造并返回[枚举]订单状态：0-未付款-NOTPAY、1-已付款/待接单-PAID、2-已完成-SUCCEED、3-已关闭-CLOSED、4-已发货/配送中-SHIPPING、5-已过期-EXPIRED、6-待配送-WAITPOST查询条件
	 * 
	 * @return statusCondition [枚举]订单状态：0-未付款-NOTPAY、1-已付款/待接单-PAID、2-已完成-SUCCEED、3-已关闭-CLOSED、4-已发货/配送中-SHIPPING、5-已过期-EXPIRED、6-待配送-WAITPOST查询条件
	 */
	public Condition<OrderStatus> status() {
		this.statusCondition = new Condition<>();
		return this.statusCondition;
	}
	
	/**
	 * 获取[枚举]订单状态：0-未付款-NOTPAY、1-已付款/待接单-PAID、2-已完成-SUCCEED、3-已关闭-CLOSED、4-已发货/配送中-SHIPPING、5-已过期-EXPIRED、6-待配送-WAITPOST查询条件
	 * 
	 * @return statusCondition [枚举]订单状态：0-未付款-NOTPAY、1-已付款/待接单-PAID、2-已完成-SUCCEED、3-已关闭-CLOSED、4-已发货/配送中-SHIPPING、5-已过期-EXPIRED、6-待配送-WAITPOST查询条件
	 */
	public Condition<OrderStatus> getStatusCondition() {
		return statusCondition;
	}

	/**
	 * 设置[枚举]订单状态：0-未付款-NOTPAY、1-已付款/待接单-PAID、2-已完成-SUCCEED、3-已关闭-CLOSED、4-已发货/配送中-SHIPPING、5-已过期-EXPIRED、6-待配送-WAITPOST查询条件
	 * 
	 * @param statusCondition [枚举]订单状态：0-未付款-NOTPAY、1-已付款/待接单-PAID、2-已完成-SUCCEED、3-已关闭-CLOSED、4-已发货/配送中-SHIPPING、5-已过期-EXPIRED、6-待配送-WAITPOST查询条件
	 */
	public void setStatusCondition(Condition<OrderStatus> statusCondition) {
		this.statusCondition = statusCondition;
	}

	/**
	 * 构造并返回退款金额查询条件
	 * 
	 * @return refundAmountCondition 退款金额查询条件
	 */
	public Condition<BigDecimal> refundAmount() {
		this.refundAmountCondition = new Condition<>();
		return this.refundAmountCondition;
	}
	
	/**
	 * 获取退款金额查询条件
	 * 
	 * @return refundAmountCondition 退款金额查询条件
	 */
	public Condition<BigDecimal> getRefundAmountCondition() {
		return refundAmountCondition;
	}

	/**
	 * 设置退款金额查询条件
	 * 
	 * @param refundAmountCondition 退款金额查询条件
	 */
	public void setRefundAmountCondition(Condition<BigDecimal> refundAmountCondition) {
		this.refundAmountCondition = refundAmountCondition;
	}

	/**
	 * 构造并返回[枚举]退款状态：0-未退款-NO_REFUND、1-部分退款-PART_REFUND、2-完全退款-ALL_REFUND查询条件
	 * 
	 * @return refundStatusCondition [枚举]退款状态：0-未退款-NO_REFUND、1-部分退款-PART_REFUND、2-完全退款-ALL_REFUND查询条件
	 */
	public Condition<OrderRefundStatus> refundStatus() {
		this.refundStatusCondition = new Condition<>();
		return this.refundStatusCondition;
	}
	
	/**
	 * 获取[枚举]退款状态：0-未退款-NO_REFUND、1-部分退款-PART_REFUND、2-完全退款-ALL_REFUND查询条件
	 * 
	 * @return refundStatusCondition [枚举]退款状态：0-未退款-NO_REFUND、1-部分退款-PART_REFUND、2-完全退款-ALL_REFUND查询条件
	 */
	public Condition<OrderRefundStatus> getRefundStatusCondition() {
		return refundStatusCondition;
	}

	/**
	 * 设置[枚举]退款状态：0-未退款-NO_REFUND、1-部分退款-PART_REFUND、2-完全退款-ALL_REFUND查询条件
	 * 
	 * @param refundStatusCondition [枚举]退款状态：0-未退款-NO_REFUND、1-部分退款-PART_REFUND、2-完全退款-ALL_REFUND查询条件
	 */
	public void setRefundStatusCondition(Condition<OrderRefundStatus> refundStatusCondition) {
		this.refundStatusCondition = refundStatusCondition;
	}

	/**
	 * 构造并返回退款备注查询条件
	 * 
	 * @return refundRemarksCondition 退款备注查询条件
	 */
	public Condition<String> refundRemarks() {
		this.refundRemarksCondition = new Condition<>();
		return this.refundRemarksCondition;
	}
	
	/**
	 * 获取退款备注查询条件
	 * 
	 * @return refundRemarksCondition 退款备注查询条件
	 */
	public Condition<String> getRefundRemarksCondition() {
		return refundRemarksCondition;
	}

	/**
	 * 设置退款备注查询条件
	 * 
	 * @param refundRemarksCondition 退款备注查询条件
	 */
	public void setRefundRemarksCondition(Condition<String> refundRemarksCondition) {
		this.refundRemarksCondition = refundRemarksCondition;
	}

	/**
	 * 构造并返回下单时间查询条件
	 * 
	 * @return orderTimeCondition 下单时间查询条件
	 */
	public Condition<LocalDateTime> orderTime() {
		this.orderTimeCondition = new Condition<>();
		return this.orderTimeCondition;
	}
	
	/**
	 * 获取下单时间查询条件
	 * 
	 * @return orderTimeCondition 下单时间查询条件
	 */
	public Condition<LocalDateTime> getOrderTimeCondition() {
		return orderTimeCondition;
	}

	/**
	 * 设置下单时间查询条件
	 * 
	 * @param orderTimeCondition 下单时间查询条件
	 */
	public void setOrderTimeCondition(Condition<LocalDateTime> orderTimeCondition) {
		this.orderTimeCondition = orderTimeCondition;
	}

	/**
	 * 构造并返回取消时间查询条件
	 * 
	 * @return cancelTimeCondition 取消时间查询条件
	 */
	public Condition<LocalDateTime> cancelTime() {
		this.cancelTimeCondition = new Condition<>();
		return this.cancelTimeCondition;
	}
	
	/**
	 * 获取取消时间查询条件
	 * 
	 * @return cancelTimeCondition 取消时间查询条件
	 */
	public Condition<LocalDateTime> getCancelTimeCondition() {
		return cancelTimeCondition;
	}

	/**
	 * 设置取消时间查询条件
	 * 
	 * @param cancelTimeCondition 取消时间查询条件
	 */
	public void setCancelTimeCondition(Condition<LocalDateTime> cancelTimeCondition) {
		this.cancelTimeCondition = cancelTimeCondition;
	}

	/**
	 * 构造并返回交易关闭时间查询条件
	 * 
	 * @return closeTimeCondition 交易关闭时间查询条件
	 */
	public Condition<LocalDateTime> closeTime() {
		this.closeTimeCondition = new Condition<>();
		return this.closeTimeCondition;
	}
	
	/**
	 * 获取交易关闭时间查询条件
	 * 
	 * @return closeTimeCondition 交易关闭时间查询条件
	 */
	public Condition<LocalDateTime> getCloseTimeCondition() {
		return closeTimeCondition;
	}

	/**
	 * 设置交易关闭时间查询条件
	 * 
	 * @param closeTimeCondition 交易关闭时间查询条件
	 */
	public void setCloseTimeCondition(Condition<LocalDateTime> closeTimeCondition) {
		this.closeTimeCondition = closeTimeCondition;
	}

	/**
	 * 构造并返回支付时间查询条件
	 * 
	 * @return payTimeCondition 支付时间查询条件
	 */
	public Condition<LocalDateTime> payTime() {
		this.payTimeCondition = new Condition<>();
		return this.payTimeCondition;
	}
	
	/**
	 * 获取支付时间查询条件
	 * 
	 * @return payTimeCondition 支付时间查询条件
	 */
	public Condition<LocalDateTime> getPayTimeCondition() {
		return payTimeCondition;
	}

	/**
	 * 设置支付时间查询条件
	 * 
	 * @param payTimeCondition 支付时间查询条件
	 */
	public void setPayTimeCondition(Condition<LocalDateTime> payTimeCondition) {
		this.payTimeCondition = payTimeCondition;
	}

	/**
	 * 构造并返回支付超时时间查询条件
	 * 
	 * @return payExpireTimeCondition 支付超时时间查询条件
	 */
	public Condition<LocalDateTime> payExpireTime() {
		this.payExpireTimeCondition = new Condition<>();
		return this.payExpireTimeCondition;
	}
	
	/**
	 * 获取支付超时时间查询条件
	 * 
	 * @return payExpireTimeCondition 支付超时时间查询条件
	 */
	public Condition<LocalDateTime> getPayExpireTimeCondition() {
		return payExpireTimeCondition;
	}

	/**
	 * 设置支付超时时间查询条件
	 * 
	 * @param payExpireTimeCondition 支付超时时间查询条件
	 */
	public void setPayExpireTimeCondition(Condition<LocalDateTime> payExpireTimeCondition) {
		this.payExpireTimeCondition = payExpireTimeCondition;
	}

	/**
	 * 构造并返回提货超时时间查询条件
	 * 
	 * @return pickupExpireTimeCondition 提货超时时间查询条件
	 */
	public Condition<LocalDateTime> pickupExpireTime() {
		this.pickupExpireTimeCondition = new Condition<>();
		return this.pickupExpireTimeCondition;
	}
	
	/**
	 * 获取提货超时时间查询条件
	 * 
	 * @return pickupExpireTimeCondition 提货超时时间查询条件
	 */
	public Condition<LocalDateTime> getPickupExpireTimeCondition() {
		return pickupExpireTimeCondition;
	}

	/**
	 * 设置提货超时时间查询条件
	 * 
	 * @param pickupExpireTimeCondition 提货超时时间查询条件
	 */
	public void setPickupExpireTimeCondition(Condition<LocalDateTime> pickupExpireTimeCondition) {
		this.pickupExpireTimeCondition = pickupExpireTimeCondition;
	}

	/**
	 * 构造并返回发货时间查询条件
	 * 
	 * @return shippingTimeCondition 发货时间查询条件
	 */
	public Condition<LocalDateTime> shippingTime() {
		this.shippingTimeCondition = new Condition<>();
		return this.shippingTimeCondition;
	}
	
	/**
	 * 获取发货时间查询条件
	 * 
	 * @return shippingTimeCondition 发货时间查询条件
	 */
	public Condition<LocalDateTime> getShippingTimeCondition() {
		return shippingTimeCondition;
	}

	/**
	 * 设置发货时间查询条件
	 * 
	 * @param shippingTimeCondition 发货时间查询条件
	 */
	public void setShippingTimeCondition(Condition<LocalDateTime> shippingTimeCondition) {
		this.shippingTimeCondition = shippingTimeCondition;
	}

	/**
	 * 构造并返回交易完成时间查询条件
	 * 
	 * @return endTimeCondition 交易完成时间查询条件
	 */
	public Condition<LocalDateTime> endTime() {
		this.endTimeCondition = new Condition<>();
		return this.endTimeCondition;
	}
	
	/**
	 * 获取交易完成时间查询条件
	 * 
	 * @return endTimeCondition 交易完成时间查询条件
	 */
	public Condition<LocalDateTime> getEndTimeCondition() {
		return endTimeCondition;
	}

	/**
	 * 设置交易完成时间查询条件
	 * 
	 * @param endTimeCondition 交易完成时间查询条件
	 */
	public void setEndTimeCondition(Condition<LocalDateTime> endTimeCondition) {
		this.endTimeCondition = endTimeCondition;
	}

	/**
	 * 构造并返回[枚举]买家类型：0-会员-MEMBER、2-商户用户-MERCHANT_USER查询条件
	 * 
	 * @return buyerTypeCondition [枚举]买家类型：0-会员-MEMBER、2-商户用户-MERCHANT_USER查询条件
	 */
	public Condition<OrderBuyerType> buyerType() {
		this.buyerTypeCondition = new Condition<>();
		return this.buyerTypeCondition;
	}
	
	/**
	 * 获取[枚举]买家类型：0-会员-MEMBER、2-商户用户-MERCHANT_USER查询条件
	 * 
	 * @return buyerTypeCondition [枚举]买家类型：0-会员-MEMBER、2-商户用户-MERCHANT_USER查询条件
	 */
	public Condition<OrderBuyerType> getBuyerTypeCondition() {
		return buyerTypeCondition;
	}

	/**
	 * 设置[枚举]买家类型：0-会员-MEMBER、2-商户用户-MERCHANT_USER查询条件
	 * 
	 * @param buyerTypeCondition [枚举]买家类型：0-会员-MEMBER、2-商户用户-MERCHANT_USER查询条件
	 */
	public void setBuyerTypeCondition(Condition<OrderBuyerType> buyerTypeCondition) {
		this.buyerTypeCondition = buyerTypeCondition;
	}

	/**
	 * 构造并返回买家ID查询条件
	 * 
	 * @return buyerIdCondition 买家ID查询条件
	 */
	public Condition<String> buyerId() {
		this.buyerIdCondition = new Condition<>();
		return this.buyerIdCondition;
	}
	
	/**
	 * 获取买家ID查询条件
	 * 
	 * @return buyerIdCondition 买家ID查询条件
	 */
	public Condition<String> getBuyerIdCondition() {
		return buyerIdCondition;
	}

	/**
	 * 设置买家ID查询条件
	 * 
	 * @param buyerIdCondition 买家ID查询条件
	 */
	public void setBuyerIdCondition(Condition<String> buyerIdCondition) {
		this.buyerIdCondition = buyerIdCondition;
	}

	/**
	 * 构造并返回卖家昵称查询条件
	 * 
	 * @return buyerNickCondition 卖家昵称查询条件
	 */
	public Condition<String> buyerNick() {
		this.buyerNickCondition = new Condition<>();
		return this.buyerNickCondition;
	}
	
	/**
	 * 获取卖家昵称查询条件
	 * 
	 * @return buyerNickCondition 卖家昵称查询条件
	 */
	public Condition<String> getBuyerNickCondition() {
		return buyerNickCondition;
	}

	/**
	 * 设置卖家昵称查询条件
	 * 
	 * @param buyerNickCondition 卖家昵称查询条件
	 */
	public void setBuyerNickCondition(Condition<String> buyerNickCondition) {
		this.buyerNickCondition = buyerNickCondition;
	}

	/**
	 * 构造并返回卖家留言查询条件
	 * 
	 * @return buyerMessageCondition 卖家留言查询条件
	 */
	public Condition<String> buyerMessage() {
		this.buyerMessageCondition = new Condition<>();
		return this.buyerMessageCondition;
	}
	
	/**
	 * 获取卖家留言查询条件
	 * 
	 * @return buyerMessageCondition 卖家留言查询条件
	 */
	public Condition<String> getBuyerMessageCondition() {
		return buyerMessageCondition;
	}

	/**
	 * 设置卖家留言查询条件
	 * 
	 * @param buyerMessageCondition 卖家留言查询条件
	 */
	public void setBuyerMessageCondition(Condition<String> buyerMessageCondition) {
		this.buyerMessageCondition = buyerMessageCondition;
	}

	/**
	 * 构造并返回[枚举]卖家类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSD、3-商户-MERCHANT查询条件
	 * 
	 * @return sellerTypeCondition [枚举]卖家类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSD、3-商户-MERCHANT查询条件
	 */
	public Condition<OrderSellerType> sellerType() {
		this.sellerTypeCondition = new Condition<>();
		return this.sellerTypeCondition;
	}
	
	/**
	 * 获取[枚举]卖家类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSD、3-商户-MERCHANT查询条件
	 * 
	 * @return sellerTypeCondition [枚举]卖家类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSD、3-商户-MERCHANT查询条件
	 */
	public Condition<OrderSellerType> getSellerTypeCondition() {
		return sellerTypeCondition;
	}

	/**
	 * 设置[枚举]卖家类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSD、3-商户-MERCHANT查询条件
	 * 
	 * @param sellerTypeCondition [枚举]卖家类型：0-平台-PLATFORM、1-集团-GROUP、2-商圈-BUSD、3-商户-MERCHANT查询条件
	 */
	public void setSellerTypeCondition(Condition<OrderSellerType> sellerTypeCondition) {
		this.sellerTypeCondition = sellerTypeCondition;
	}

	/**
	 * 构造并返回集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> groupId() {
		this.groupIdCondition = new Condition<>();
		return this.groupIdCondition;
	}
	
	/**
	 * 获取集团ID查询条件
	 * 
	 * @return groupIdCondition 集团ID查询条件
	 */
	public Condition<String> getGroupIdCondition() {
		return groupIdCondition;
	}

	/**
	 * 设置集团ID查询条件
	 * 
	 * @param groupIdCondition 集团ID查询条件
	 */
	public void setGroupIdCondition(Condition<String> groupIdCondition) {
		this.groupIdCondition = groupIdCondition;
	}

	/**
	 * 构造并返回商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}
	
	/**
	 * 获取商圈ID查询条件
	 * 
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈ID查询条件
	 * 
	 * @param busdIdCondition 商圈ID查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回商户ID查询条件
	 * 
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> merchantId() {
		this.merchantIdCondition = new Condition<>();
		return this.merchantIdCondition;
	}
	
	/**
	 * 获取商户ID查询条件
	 * 
	 * @return merchantIdCondition 商户ID查询条件
	 */
	public Condition<String> getMerchantIdCondition() {
		return merchantIdCondition;
	}

	/**
	 * 设置商户ID查询条件
	 * 
	 * @param merchantIdCondition 商户ID查询条件
	 */
	public void setMerchantIdCondition(Condition<String> merchantIdCondition) {
		this.merchantIdCondition = merchantIdCondition;
	}

	/**
	 * 构造并返回停车场ID（停车支付订单专用）查询条件
	 * 
	 * @return parkIdCondition 停车场ID（停车支付订单专用）查询条件
	 */
	public Condition<String> parkId() {
		this.parkIdCondition = new Condition<>();
		return this.parkIdCondition;
	}
	
	/**
	 * 获取停车场ID（停车支付订单专用）查询条件
	 * 
	 * @return parkIdCondition 停车场ID（停车支付订单专用）查询条件
	 */
	public Condition<String> getParkIdCondition() {
		return parkIdCondition;
	}

	/**
	 * 设置停车场ID（停车支付订单专用）查询条件
	 * 
	 * @param parkIdCondition 停车场ID（停车支付订单专用）查询条件
	 */
	public void setParkIdCondition(Condition<String> parkIdCondition) {
		this.parkIdCondition = parkIdCondition;
	}

	/**
	 * 构造并返回是否虚拟订单（1：虚拟订单，0：非虚拟订单，虚拟订单指所有商品都是虚拟商品的订单）查询条件
	 * 
	 * @return isVirtualCondition 是否虚拟订单（1：虚拟订单，0：非虚拟订单，虚拟订单指所有商品都是虚拟商品的订单）查询条件
	 */
	public Condition<Boolean> isVirtual() {
		this.isVirtualCondition = new Condition<>();
		return this.isVirtualCondition;
	}
	
	/**
	 * 获取是否虚拟订单（1：虚拟订单，0：非虚拟订单，虚拟订单指所有商品都是虚拟商品的订单）查询条件
	 * 
	 * @return isVirtualCondition 是否虚拟订单（1：虚拟订单，0：非虚拟订单，虚拟订单指所有商品都是虚拟商品的订单）查询条件
	 */
	public Condition<Boolean> getIsVirtualCondition() {
		return isVirtualCondition;
	}

	/**
	 * 设置是否虚拟订单（1：虚拟订单，0：非虚拟订单，虚拟订单指所有商品都是虚拟商品的订单）查询条件
	 * 
	 * @param isVirtualCondition 是否虚拟订单（1：虚拟订单，0：非虚拟订单，虚拟订单指所有商品都是虚拟商品的订单）查询条件
	 */
	public void setIsVirtualCondition(Condition<Boolean> isVirtualCondition) {
		this.isVirtualCondition = isVirtualCondition;
	}

	/**
	 * 构造并返回[枚举]提货类型：0-上门提货-SELF、1-线上授予-ONLINE、2-商户送货-MERCHANT、3-快递-POST查询条件
	 * 
	 * @return pickupTypeCondition [枚举]提货类型：0-上门提货-SELF、1-线上授予-ONLINE、2-商户送货-MERCHANT、3-快递-POST查询条件
	 */
	public Condition<OrderPickupType> pickupType() {
		this.pickupTypeCondition = new Condition<>();
		return this.pickupTypeCondition;
	}
	
	/**
	 * 获取[枚举]提货类型：0-上门提货-SELF、1-线上授予-ONLINE、2-商户送货-MERCHANT、3-快递-POST查询条件
	 * 
	 * @return pickupTypeCondition [枚举]提货类型：0-上门提货-SELF、1-线上授予-ONLINE、2-商户送货-MERCHANT、3-快递-POST查询条件
	 */
	public Condition<OrderPickupType> getPickupTypeCondition() {
		return pickupTypeCondition;
	}

	/**
	 * 设置[枚举]提货类型：0-上门提货-SELF、1-线上授予-ONLINE、2-商户送货-MERCHANT、3-快递-POST查询条件
	 * 
	 * @param pickupTypeCondition [枚举]提货类型：0-上门提货-SELF、1-线上授予-ONLINE、2-商户送货-MERCHANT、3-快递-POST查询条件
	 */
	public void setPickupTypeCondition(Condition<OrderPickupType> pickupTypeCondition) {
		this.pickupTypeCondition = pickupTypeCondition;
	}

	/**
	 * 构造并返回是否需要上门自提（1：需要，会员自己上门自提，0：不需要）查询条件
	 * 
	 * @return pickupCondition 是否需要上门自提（1：需要，会员自己上门自提，0：不需要）查询条件
	 */
	public Condition<Boolean> pickup() {
		this.pickupCondition = new Condition<>();
		return this.pickupCondition;
	}
	
	/**
	 * 获取是否需要上门自提（1：需要，会员自己上门自提，0：不需要）查询条件
	 * 
	 * @return pickupCondition 是否需要上门自提（1：需要，会员自己上门自提，0：不需要）查询条件
	 */
	public Condition<Boolean> getPickupCondition() {
		return pickupCondition;
	}

	/**
	 * 设置是否需要上门自提（1：需要，会员自己上门自提，0：不需要）查询条件
	 * 
	 * @param pickupCondition 是否需要上门自提（1：需要，会员自己上门自提，0：不需要）查询条件
	 */
	public void setPickupCondition(Condition<Boolean> pickupCondition) {
		this.pickupCondition = pickupCondition;
	}

	/**
	 * 构造并返回剩余可提货数量查询条件
	 * 
	 * @return pickupRemainCondition 剩余可提货数量查询条件
	 */
	public Condition<Integer> pickupRemain() {
		this.pickupRemainCondition = new Condition<>();
		return this.pickupRemainCondition;
	}
	
	/**
	 * 获取剩余可提货数量查询条件
	 * 
	 * @return pickupRemainCondition 剩余可提货数量查询条件
	 */
	public Condition<Integer> getPickupRemainCondition() {
		return pickupRemainCondition;
	}

	/**
	 * 设置剩余可提货数量查询条件
	 * 
	 * @param pickupRemainCondition 剩余可提货数量查询条件
	 */
	public void setPickupRemainCondition(Condition<Integer> pickupRemainCondition) {
		this.pickupRemainCondition = pickupRemainCondition;
	}

	/**
	 * 构造并返回订单层级（0：父订单，1：子订单，仅支持两级结构，子订单精确到卖家，一个订单可以包含多个卖家的商品，子订单中只会有一个卖家的商品）查询条件
	 * 
	 * @return levelCondition 订单层级（0：父订单，1：子订单，仅支持两级结构，子订单精确到卖家，一个订单可以包含多个卖家的商品，子订单中只会有一个卖家的商品）查询条件
	 */
	public Condition<Integer> level() {
		this.levelCondition = new Condition<>();
		return this.levelCondition;
	}
	
	/**
	 * 获取订单层级（0：父订单，1：子订单，仅支持两级结构，子订单精确到卖家，一个订单可以包含多个卖家的商品，子订单中只会有一个卖家的商品）查询条件
	 * 
	 * @return levelCondition 订单层级（0：父订单，1：子订单，仅支持两级结构，子订单精确到卖家，一个订单可以包含多个卖家的商品，子订单中只会有一个卖家的商品）查询条件
	 */
	public Condition<Integer> getLevelCondition() {
		return levelCondition;
	}

	/**
	 * 设置订单层级（0：父订单，1：子订单，仅支持两级结构，子订单精确到卖家，一个订单可以包含多个卖家的商品，子订单中只会有一个卖家的商品）查询条件
	 * 
	 * @param levelCondition 订单层级（0：父订单，1：子订单，仅支持两级结构，子订单精确到卖家，一个订单可以包含多个卖家的商品，子订单中只会有一个卖家的商品）查询条件
	 */
	public void setLevelCondition(Condition<Integer> levelCondition) {
		this.levelCondition = levelCondition;
	}

	/**
	 * 构造并返回父订单ID查询条件
	 * 
	 * @return parentIdCondition 父订单ID查询条件
	 */
	public Condition<String> parentId() {
		this.parentIdCondition = new Condition<>();
		return this.parentIdCondition;
	}
	
	/**
	 * 获取父订单ID查询条件
	 * 
	 * @return parentIdCondition 父订单ID查询条件
	 */
	public Condition<String> getParentIdCondition() {
		return parentIdCondition;
	}

	/**
	 * 设置父订单ID查询条件
	 * 
	 * @param parentIdCondition 父订单ID查询条件
	 */
	public void setParentIdCondition(Condition<String> parentIdCondition) {
		this.parentIdCondition = parentIdCondition;
	}

	/**
	 * 构造并返回[枚举]类型：0-购物订单-BUY、1-扫码支付-SCAN_PAY、2-停车支付-PARK、3-商户停车券-MERCHANT_COUPON_BUY、4-购买悦卡-CARD_BUY、5-充值悦币-RECHARGE_COIN、6-仪表充值-DOORNO_RECHARGE、7-商户仪表充值-MERCHANT_DOORNO_RECHARGE、8-商户会员等级充值-MERCHANT_LEVEL_BUY、9-疯狂砍价-BARGAIN、10-秒杀-SECKILL、11-限时折扣-LIMIT_SALES、12-积分兑换-POINTS、13-购买套餐-MEAL、14-全民拼团-GROUPON、15-抽奖-LOTTERY、16-物业缴费-PROPERTY_PAY_COST、17-商户物业缴费-MERCHANT_PROPERTY_PAY_COST、18-配送到家-DELIVERY_TO_HOME、19-发放礼包(不能被查询到)-GIVING_GIFT_BAG、20-实体卡支付-ENTITY_CARD_PAY、21-商品券领取-COUPON、22-京东商城订单-JD、23-免费领取-FREE、24-活动订单-ACTIVITY查询条件
	 * 
	 * @return typeCondition [枚举]类型：0-购物订单-BUY、1-扫码支付-SCAN_PAY、2-停车支付-PARK、3-商户停车券-MERCHANT_COUPON_BUY、4-购买悦卡-CARD_BUY、5-充值悦币-RECHARGE_COIN、6-仪表充值-DOORNO_RECHARGE、7-商户仪表充值-MERCHANT_DOORNO_RECHARGE、8-商户会员等级充值-MERCHANT_LEVEL_BUY、9-疯狂砍价-BARGAIN、10-秒杀-SECKILL、11-限时折扣-LIMIT_SALES、12-积分兑换-POINTS、13-购买套餐-MEAL、14-全民拼团-GROUPON、15-抽奖-LOTTERY、16-物业缴费-PROPERTY_PAY_COST、17-商户物业缴费-MERCHANT_PROPERTY_PAY_COST、18-配送到家-DELIVERY_TO_HOME、19-发放礼包(不能被查询到)-GIVING_GIFT_BAG、20-实体卡支付-ENTITY_CARD_PAY、21-商品券领取-COUPON、22-京东商城订单-JD、23-免费领取-FREE、24-活动订单-ACTIVITY查询条件
	 */
	public Condition<OrderType> type() {
		this.typeCondition = new Condition<>();
		return this.typeCondition;
	}
	
	/**
	 * 获取[枚举]类型：0-购物订单-BUY、1-扫码支付-SCAN_PAY、2-停车支付-PARK、3-商户停车券-MERCHANT_COUPON_BUY、4-购买悦卡-CARD_BUY、5-充值悦币-RECHARGE_COIN、6-仪表充值-DOORNO_RECHARGE、7-商户仪表充值-MERCHANT_DOORNO_RECHARGE、8-商户会员等级充值-MERCHANT_LEVEL_BUY、9-疯狂砍价-BARGAIN、10-秒杀-SECKILL、11-限时折扣-LIMIT_SALES、12-积分兑换-POINTS、13-购买套餐-MEAL、14-全民拼团-GROUPON、15-抽奖-LOTTERY、16-物业缴费-PROPERTY_PAY_COST、17-商户物业缴费-MERCHANT_PROPERTY_PAY_COST、18-配送到家-DELIVERY_TO_HOME、19-发放礼包(不能被查询到)-GIVING_GIFT_BAG、20-实体卡支付-ENTITY_CARD_PAY、21-商品券领取-COUPON、22-京东商城订单-JD、23-免费领取-FREE、24-活动订单-ACTIVITY查询条件
	 * 
	 * @return typeCondition [枚举]类型：0-购物订单-BUY、1-扫码支付-SCAN_PAY、2-停车支付-PARK、3-商户停车券-MERCHANT_COUPON_BUY、4-购买悦卡-CARD_BUY、5-充值悦币-RECHARGE_COIN、6-仪表充值-DOORNO_RECHARGE、7-商户仪表充值-MERCHANT_DOORNO_RECHARGE、8-商户会员等级充值-MERCHANT_LEVEL_BUY、9-疯狂砍价-BARGAIN、10-秒杀-SECKILL、11-限时折扣-LIMIT_SALES、12-积分兑换-POINTS、13-购买套餐-MEAL、14-全民拼团-GROUPON、15-抽奖-LOTTERY、16-物业缴费-PROPERTY_PAY_COST、17-商户物业缴费-MERCHANT_PROPERTY_PAY_COST、18-配送到家-DELIVERY_TO_HOME、19-发放礼包(不能被查询到)-GIVING_GIFT_BAG、20-实体卡支付-ENTITY_CARD_PAY、21-商品券领取-COUPON、22-京东商城订单-JD、23-免费领取-FREE、24-活动订单-ACTIVITY查询条件
	 */
	public Condition<OrderType> getTypeCondition() {
		return typeCondition;
	}

	/**
	 * 设置[枚举]类型：0-购物订单-BUY、1-扫码支付-SCAN_PAY、2-停车支付-PARK、3-商户停车券-MERCHANT_COUPON_BUY、4-购买悦卡-CARD_BUY、5-充值悦币-RECHARGE_COIN、6-仪表充值-DOORNO_RECHARGE、7-商户仪表充值-MERCHANT_DOORNO_RECHARGE、8-商户会员等级充值-MERCHANT_LEVEL_BUY、9-疯狂砍价-BARGAIN、10-秒杀-SECKILL、11-限时折扣-LIMIT_SALES、12-积分兑换-POINTS、13-购买套餐-MEAL、14-全民拼团-GROUPON、15-抽奖-LOTTERY、16-物业缴费-PROPERTY_PAY_COST、17-商户物业缴费-MERCHANT_PROPERTY_PAY_COST、18-配送到家-DELIVERY_TO_HOME、19-发放礼包(不能被查询到)-GIVING_GIFT_BAG、20-实体卡支付-ENTITY_CARD_PAY、21-商品券领取-COUPON、22-京东商城订单-JD、23-免费领取-FREE、24-活动订单-ACTIVITY查询条件
	 * 
	 * @param typeCondition [枚举]类型：0-购物订单-BUY、1-扫码支付-SCAN_PAY、2-停车支付-PARK、3-商户停车券-MERCHANT_COUPON_BUY、4-购买悦卡-CARD_BUY、5-充值悦币-RECHARGE_COIN、6-仪表充值-DOORNO_RECHARGE、7-商户仪表充值-MERCHANT_DOORNO_RECHARGE、8-商户会员等级充值-MERCHANT_LEVEL_BUY、9-疯狂砍价-BARGAIN、10-秒杀-SECKILL、11-限时折扣-LIMIT_SALES、12-积分兑换-POINTS、13-购买套餐-MEAL、14-全民拼团-GROUPON、15-抽奖-LOTTERY、16-物业缴费-PROPERTY_PAY_COST、17-商户物业缴费-MERCHANT_PROPERTY_PAY_COST、18-配送到家-DELIVERY_TO_HOME、19-发放礼包(不能被查询到)-GIVING_GIFT_BAG、20-实体卡支付-ENTITY_CARD_PAY、21-商品券领取-COUPON、22-京东商城订单-JD、23-免费领取-FREE、24-活动订单-ACTIVITY查询条件
	 */
	public void setTypeCondition(Condition<OrderType> typeCondition) {
		this.typeCondition = typeCondition;
	}

	/**
	 * 构造并返回是否是叶子订单（统计订单金额时，使用叶子订单来统计）查询条件
	 * 
	 * @return leafCondition 是否是叶子订单（统计订单金额时，使用叶子订单来统计）查询条件
	 */
	public Condition<Boolean> leaf() {
		this.leafCondition = new Condition<>();
		return this.leafCondition;
	}
	
	/**
	 * 获取是否是叶子订单（统计订单金额时，使用叶子订单来统计）查询条件
	 * 
	 * @return leafCondition 是否是叶子订单（统计订单金额时，使用叶子订单来统计）查询条件
	 */
	public Condition<Boolean> getLeafCondition() {
		return leafCondition;
	}

	/**
	 * 设置是否是叶子订单（统计订单金额时，使用叶子订单来统计）查询条件
	 * 
	 * @param leafCondition 是否是叶子订单（统计订单金额时，使用叶子订单来统计）查询条件
	 */
	public void setLeafCondition(Condition<Boolean> leafCondition) {
		this.leafCondition = leafCondition;
	}

	/**
	 * 构造并返回旧订单号查询条件
	 * 
	 * @return oldOrderNoCondition 旧订单号查询条件
	 */
	public Condition<String> oldOrderNo() {
		this.oldOrderNoCondition = new Condition<>();
		return this.oldOrderNoCondition;
	}
	
	/**
	 * 获取旧订单号查询条件
	 * 
	 * @return oldOrderNoCondition 旧订单号查询条件
	 */
	public Condition<String> getOldOrderNoCondition() {
		return oldOrderNoCondition;
	}

	/**
	 * 设置旧订单号查询条件
	 * 
	 * @param oldOrderNoCondition 旧订单号查询条件
	 */
	public void setOldOrderNoCondition(Condition<String> oldOrderNoCondition) {
		this.oldOrderNoCondition = oldOrderNoCondition;
	}

}
